// "use strict";

// let hasDriversLicense = false;
// const passTest = true;

// if (passTest) hasDriverLicense = true;
// if (hasDriversLicense) console.log("I can drive :D");

// function logger() {
//   console.log("My name is zzz");
// }
// logger();
// logger();
// logger();

// function fruitProcessor(apples, oranges) {
//   console.log(apples, oranges);
//   const juice = `Juice with ${apples} apples and ${oranges} oranges.`;
//   return juice;
// }
// const appleJuice = fruitProcessor(5, 0);
// console.log(appleJuice);

// const appleOrangeJuice = fruitProcessor(2, 4);
// console.log(appleOrangeJuice);

// // Function declaration
// function calcAge1(birthYear) {
//   return new Date().getFullYear() - birthYear;
// }
// const age1 = calcAge1(1999);

// // Function expression
// const calcAge2 = function (birthYear) {
//   return new Date().getFullYear() - birthYear;
// };
// const age2 = calcAge2(1999);
// console.log(age1, age2);

// // Function expression
// const calcAge2 = function (birthYear) {
//   return new Date().getFullYear() - birthYear;
// };
// //Arrow fuction
// const calcAge3 = (birthYear) => new Date().getFullYear() - birthYear;
// const age3 = calcAge3(1999);
// console.log(age3);

// const yearsUntilRetirement = (birthYear, firstName) => {
//   const age = new Date().getFullYear() - birthYear;
//   const retirement = 65 - age;
//   //   return retirement;
//   return `${firstName} retires in ${retirement} years`;
// };
// console.log(yearsUntilRetirement(1991, "zzz"));
// console.log(yearsUntilRetirement(1999, "Bob"));

// function cutFruitPieces(fruit) {
//   return fruit * 4;
// }

// function fruitProcessor(apples, oranges) {
//   const applePieces = cutFruitPieces(apples);
//   const orangePieces = cutFruitPieces(oranges);
//   const juice = `Juice with ${applePieces} pieces of apples and ${orangePieces}  pieces of oranges.`;
//   return juice;
// }

// console.log(fruitProcessor(2, 3));

// const calcAge = function (birthYear) {
//   return new Date().getFullYear() - birthYear;
// };
// const yearsUntilRetirement = function (birthYear, firstName) {
//   const age = calcAge(birthYear);
//   const retirement = 65 - age;
//   if (retirement > 0) {
//     console.log(`${firstName} retires in ${retirement} years`);
//     return retirement;
//   } else {
//     console.log(`${firstName} has already retired ✌`);
//     return -1;
//   }
// };
// console.log(yearsUntilRetirement(1999, "zzz"));
// console.log(yearsUntilRetirement(1950, "aaa"));

// function calcAverage(...scores) {
//   //   return (score1 + score2 + score3) / 3;
//   const sum = scores.reduce((acc, current) => acc + current, 0);
//   return sum / scores.length;
// }

// function checkWinner(avgDolphins, avgKoalas) {
//   if (avgDolphins >= 2 * avgKoalas) {
//     console.log(`Dolphins win 🏆(${avgDolphins} vs. ${avgKoalas})`);
//   } else if (avgKoalas >= 2 * avgDolphins) {
//     console.log(`Koalas win 🏆(${avgKoalas} vs. ${avgDolphins})`);
//   } else {
//     console.log("No team wins ...");
//   }
// }

// //Test1
// let scoreDolphins = calcAverage(44, 23, 71);
// let scoreKoalas = calcAverage(65, 54, 49);
// console.log(scoreDolphins, scoreKoalas);
// checkWinner(scoreDolphins, scoreKoalas);

// //Test2
// scoreDolphins = calcAverage(85, 54, 41);
// scoreKoalas = calcAverage(23, 34, 27);
// checkWinner(scoreDolphins, scoreKoalas);

// let nameStr = "zzz";
// nameStr.name = "zzz2";
// console.log(nameStr.name);

// let name1 = "zzz";
// let name2 = new String("zzz");
// name1.name = "zzz2";
// name2.name = "zzz2";
// console.log(name1.name); // undefined
// console.log(name2.name); // zzz2
// console.log(typeof name1); // string
// console.log(typeof name2); // object

// let num1 = 5;
// let num2 = num1;
// num1 = 6;
// console.log(num1, num2); // 这两个变量可以独立使用，互不干扰

// let obj1 = new Object();
// let obj2 = obj1;
// obj1.name = "zzz";
// console.log(obj2.name); // zzz

// Date
// 1.当前日期和时间
// let now = new Date();
// console.log(now);
// // 2.传入毫秒数
// let date1 = new Date(1761268892354);
// console.log(date1); // 转换为对应日期
// // 3.传入日期字符串
// let date2 = new Date("2025-10-25T06:30:00Z"); // ISO 8601 格式，Z 表示 UTC
// let date3 = new Date("2025-10-25T06:30:00+08:00"); // ISO 8601 格式，表示东八区时间
// let date4 = new Date("October 24, 2025 14:30:00"); // 解析因浏览器/地区而异，可能不可靠
// console.log(date2);
// console.log(date3);
// console.log(date4);
// // 4.传入日期组件（年，月，日，时，分，秒，毫秒)
// // 注意：月份是从0开始计数的（0=一月，1=二月，... , 11 = 十二月)
// let specificDate = new Date(2025, 9, 24);
// console.log(specificDate);

// let parsedTime = Date.parse("2025-10-24");
// console.log(parsedTime);

// let date = new Date(2025, 9, 24, 9, 40, 35);
// // 获取年，月，日，星期
// console.log(date.getFullYear()); // 2025 (使用 getFullYear, 不要用 getYear)
// console.log(date.getMonth()); // 9 (注意：月份是 0-11)
// console.log(date.getDate()); // 24 (一个月中的第几天)
// console.log(date.getDay()); // 5 (星期几，0=星期日, 6=星期六)
// // 获取时、分、秒、毫秒
// console.log(date.getHours()); // 9
// console.log(date.getMinutes()); // 40
// console.log(date.getSeconds()); // 35
// console.log(date.getMilliseconds()); // 0
// // 获取时间戳
// console.log(date.getTime()); // 1761270035000
// // UTC版本的方法（返回基于UTC的时间)
// console.log(date.getUTCHours()); // 1（北京时间+8，所以UTC时间是9 - 8 = 1

// let date = new Date();
// // 设置年、月、日等
// date.setFullYear(2025);
// date.setMonth(9);
// date.setDate(24);

// date.setHours(9);
// date.setMinutes(59);
// date.setSeconds(20);
// console.log(date.toLocaleDateString()); //2025/10/24

// date = new Date(2025, 1, 29);
// console.log(date); // 自动调整为2025-02-28

// let date = new Date();
// console.log(date.toString()); // Fri Oct 24 2025 10:14:32 GMT+0800 (中国标准时间)
// console.log(date.toDateString()); // Fri Oct 24 2025
// console.log(date.toTimeString()); // 10:14:32 GMT+0800 (中国标准时间)

// console.log(date.toLocaleDateString()); // 2025/10/24
// console.log(date.toLocaleTimeString()); // 10:14:32
// console.log(date.toLocaleString()); // 2025/10/24 10:14:32

// // 用于网络传输或存储的标准格式
// console.log(date.toISOString()); //2025-10-24T02:14:32.478Z
// console.log(date.toUTCString()); // Fri, 24 Oct 2025 02:14:32 GMT
// console.log(date.toJSON()); // 2025-10-24T02:14:32.478Z

// let start = new Date(2025, 0, 1); //2025年1月1日
// let end = new Date(2025, 11, 31); // 2025年12月31日

// // 比较日期
// console.log(start < end); // true
// // 计算日期差(毫秒)
// let differenceInMs = end - start;
// console.log(differenceInMs); // 两个日期之间相差的毫秒数
// // 将毫秒转换为天
// let differenceInDays = differenceInMs / (1000 * 60 * 60 * 24);
// console.log(differenceInDays); // ~364天(取决于具体年份)

// // 创建一个未来的日期(例如，10天后)
// let today = new Date();
// let tenDaysLater = new Date(today.getTime() + 10 * 24 * 60 * 60 * 1000);
// console.log(tenDaysLater); // 2025-11-03T02:29:41.154Z

//标志改变匹配行为：
// // i - 忽略大小写
// let caseInsensitive = /hello/i;
// console.log(caseInsensitive.test("Hello")); // true
// console.log(caseInsensitive.test("HELLO")); // true

// // g - 全局匹配（找到所有匹配，而不是第一个)
// let globalPattern = /a/g;
// let str = "abcabc";
// console.log(str.match(globalPattern)); // ["a","a"]

// // m - 多行模式
// let multiLine = /^test/m;
// let text = "first line\ntest line";
// let text2 = "first line test line";
// let text3 = `first line
//                 test line`;
// console.log(multiLine.test(text)); // true
// console.log(multiLine.test(text2)); // false
// console.log(multiLine.test(text3)); // fasle

// //s - dotAll模式，表示元字符.匹配任何字符(包括\n或\r)
// let dotAll = /test.something/s;
// console.log(dotAll.test("test\nsomething")); // true

// //u - Unicode模式，启用Unicode匹配
// let unicodePattern = /\u{1F60A}/u;
// console.log(unicodePattern.test("😊")); //true

// // y - 粘附模式（从lastIndex开始精确匹配)
// let sticky = /a/y;
// sticky.lastIndex = 1;
// console.log(sticky.test("ba")); // true
// console.log(sticky.test("ab")); // false(从位置1开始不是a)

// // 简单字符类
// let pattern1 = /[abc]/; // 匹配 a, b 或 c
// console.log("cdefga".match(pattern1)); // ["c"]

// let pattern2 = /[^abc]/; // 匹配除了 a, b, c 的任意字符
// console.log("cdefga".match(pattern2)); // ["d"]

// let pattern3 = /[a-z]/; // 匹配任意小写字母
// console.log("I am a kid".match(pattern3)); // ["a"]
// let pattern4 = /[A-Z]/; // 匹配任意大写字母
// console.log("I am a kid".match(pattern4)); // ["I"]
// let pattern5 = /[0-9]/; // 匹配数字
// console.log("我有1个苹果".match(pattern5)); // ["1"]
// // 预定义字符类
// let digit = /\d/; // 数字，等同于 [0-9]
// console.log(digit.test("abcdefg")); // false
// let notDigit = /\D/; // 非数字，等同于 [^0-9]
// console.log(notDigit.test("....")); // true
// let wordChar = /\w/; // 单词字符，等同于 [a-zA-Z0-9_]
// console.log(wordChar.test("1234569")); // true
// let notWordChar = /\W/; // 非单词字符
// console.log(notWordChar.test("...")); // true
// let whitespace = /\s/; // 空白字符（空格、制表符、换行等）
// console.log(whitespace.test("\n123")); // true
// let notWhitespace = /\S/; // 非空白字符
// console.log(notWhitespace.test(" ")); // fasle

// 基本量词
// let zeroOrMore = /a*/; // 0个或多个a
// let oneOrMore = /a+/; // 1个或多个a
// let zeroOrOne = /a?/; // 0个或1个a
// const str = "aaa";
// const str2 = "bbab";
// console.log(str.match(zeroOrMore)); // ["aaa"]
// console.log(str2.match(oneOrMore)); // ["a"]

// // 精确量词
// let exactlyThree = /a{3}/; // 正好3个a
// let threeOrMore = /a{3,}/; // 3个或更多a
// let betweenThreeAndFive = /a{3,5}/; // 3到5个a

// console.log(str.match(exactlyThree)); // ["aaa"]

// // 贪婪 vs 非贪婪
// let greedy = /a+/; // 匹配尽可能多的a
// let lazy = /a+?/; // 匹配尽可能少的a
// console.log(str.match(greedy)); // ["aaa"]
// console.log(str2.match(lazy)); // ["a"]

// //捕获组
// let pattern = /(\d{4})-(\d{2})-(\d{2})/;
// let date = "2025-10-24";
// let match = pattern.exec(date);
// console.log(match[0]); // 2025-10-24
// console.log(match[1]); // 2025
// console.log(match[2]); // 10
// console.log(match[3]); // 24

// //命名捕获组
// pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
// let match2 = pattern.exec(date);
// console.log(match2.groups.year); // 2025
// console.log(match2.groups.month); // 10
// console.log(match2.groups.day); // 24

// //非捕获组
// pattern = /(?:Mr|Mrs|Miss)\.(\w+)/;
// let string = "Hello,Mrs.Smith";
// let match3 = pattern.exec(string);
// console.log(match3);
// console.log(match3[1]); // Smith

// //正向前瞻 - 后面跟着特定模式
// let positiveLookahead = /abc(?=def)/; //匹配后面跟着def的abc
// console.log(positiveLookahead.test("abcdef")); // true
// console.log(positiveLookahead.test("abczxy")); // false

// //负向前瞻 - 后面不跟着特定模式
// let negativeLookahead = /abc(?!def)/; //匹配后面不跟着def的abc
// console.log(negativeLookahead.test("abcdef")); // false
// console.log(negativeLookahead.test("abczxy")); // true

// //正向后顾 - 前面是特定模式
// let positiveLookbehind = /(?<=abc)def/;
// console.log(positiveLookbehind.test("abcdef")); // true
// console.log(positiveLookbehind.test("xyzdef")); // false

// // 负向后顾 - 前面不是特定模式
// let negativeLookbehind = /(?<!abc)def/; // 匹配前面不是abc的def
// console.log(negativeLookbehind.test("abcdef")); // false
// console.log(negativeLookbehind.test("xyzdef")); // true

// let pattern = /test/gi;
// // test()  - 测试是否匹配
// console.log(pattern.test("This is a test")); // true
// // exec() - 执行搜索，返回详细信息
// pattern.lastIndex = 0; // 重置开始位置
// let result = pattern.exec("test is test");
// console.log(result[0]); // test
// console.log(result.index); // 0
// console.log(result.input); // test is test
// //toString() - 返回正则表达式字符串
// console.log(pattern.toString()); // /test/gi
// // [Symbol.match]() - 被String.prototype.match调用
// console.log("test".match(pattern)); // ["test"]

// let price = 1234.5;
// console.log(
//   price.toLocaleString("zh-CN", {
//     style: "currency",
//     currency: "CNY",
//   })
// ); // ¥1,234.50

// const obj = {
//   name: "张三",
//   age: 25,
//   hobbies: ["阅读", "运动"],
//   address: {
//     city: "北京",
//     street: "朝阳路",
//   },
//   date: new Date(),
//   score: undefined, // 会被忽略
//   func: function () {}, // 会被忽略
// };

// // 使用替换函数
// function replacer(key, value) {
//   if (typeof value === "string") {
//     return value.toUpperCase();
//   }
//   return value;
// }
// console.log(JSON.stringify(obj, replacer, 2));

// // 只序列化指定属性
// console.log(JSON.stringify(obj, null, 4));

// const jsonString = '{"name":"John"}';
// console.log(JSON.parse(jsonString));

// 创建数组
// // 1. 数组字面量
// let fruit = ["apple", "banana", "orange"];
// let emptyArray = [];
// // 2. Array构造函数
// let colors = new Array("red", "blue", "green");
// let numbers = new Array(5); // 长度为5的空数组
// let names = new Array("Mark");
// console.log(colors); // [ 'red', 'blue', 'green' ]
// console.log(numbers); // [ <5 empty items> ]
// console.log(names); // [ 'Mark' ]
// // 3. Array.of()
// let arr1 = Array.of(1, 2, 3); // [1,2,3]
// let arr2 = Array.of(5); // [5] - 与new Array(5)不同
// console.log(arr1); // [ 1, 2, 3 ]
// console.log(arr2); // [ 5 ]
// // 4.Array.from() - 从类数组对象或可迭代对象创建
// let fromString = Array.from("hello");
// let fromSet = Array.from(new Set([1, 2, 3]));
// console.log(fromString); // [ 'h', 'e', 'l', 'l', 'o' ]
// console.log(fromSet); // [ 1, 2, 3 ]

//数组空位
// const options = [1, , , , 5];
// for (const option of options) {
//   console.log(option === undefined); // false true true true false
// }
// console.log(options.map(() => 6));
// console.log(options.join("-"));

//数组索引
// let colors = ["red", "blue", "green"];
// colors[2] = "black"; // 修改第三项
// colors[3] = "brown"; //添加第四项
// console.log(colors); // [ 'red', 'blue', 'black', 'brown' ]

// 填充和复制方法
// let arr1 = [1, 2, 3, 4, 5];
// //将索引3到末尾的元素复制到索引0开始为止
// arr1.copyWithin(0, 3);
// console.log(arr1);

// let arr2 = [1, 2, 3, 4, 5];
// //将索引3到4的元素赋值到索引0开始位置
// arr2.copyWithin(0, 3, 4);
// console.log(arr2);

// let arr3 = [1, 2, 3, 4, 5];
// //将倒数第2个到倒数第一个元素复制到索引0
// arr3.copyWithin(0, -2, -1);
// console.log(arr3);

// 用固定值填充整个数组
// let arr1 = [1, 2, 3, 4];
// arr1.fill(0);
// console.log(arr1); // [ 0, 0, 0, 0 ]

// // 初始化指定长度的数组
// let arr2 = new Array(3).fill("a");
// console.log(arr2); // [ 'a', 'a', 'a' ]

// let arr3 = ["a", "b", "c", "d"];
// // 从索引1开始填充到索引3之前(即索引1和2)
// arr3.fill(7, 1, 3);
// console.log(arr3); // [ 'a', 7, 7, 'd' ]

// //使用负数索引(从数组末尾开始计算)
// let arr4 = [1, 2, 3, 4, 5];
// arr4.fill(0, -3, -1); // 相当于从索引2填充到索引4
// console.log(arr4); // [ 1, 2, 0, 0, 5 ]

// // 当填充值为对象时，所有元素将指向同一个对象的引用
// let arr5 = new Array(3).fill({ name: "John" });
// arr5[0].name = "Jane";
// console.log(arr5[1].name); // "Jane" (所有元素都被修改了)

// let arr6 = Array.from({ length: 3 }, () => ({ name: "John" }));
// arr6[0].name = "Jane";
// console.log(arr6[1].name); // "John" (所有元素都是不同的引用)

// let colors = ["red", "green", "blue"];
// console.log(colors.toString()); // "red,green,blue"
// console.log(colors.valueOf()); // [ 'red', 'green', 'blue' ]
// console.log(colors.join("-")); // "red - green - blue"

// let color1 = {
//   toLocaleString() {
//     return "orangered";
//   },
//   toString() {
//     return "red";
//   },
// };
// let color2 = {
//   toLocaleString() {
//     return "skyblue";
//   },
//   toString() {
//     return "blue";
//   },
// };
// let colors = [color1, color2];
// console.log(colors.toString()); // "red,blue"
// console.log(colors.toLocaleString()); // "orangered,skyblue"

// let colors = ["red", "blue", "green"];
// console.log(colors.join("-")); // red-blue-green
// console.log(colors.join("||")); // red||blue||green

// let colors = new Array();
// let count = colors.push("red", "green");
// console.log(count); // 2
// count = colors.push("black");
// console.log(count); // 3

// let item = colors.pop();
// console.log(item); // black
// console.log(colors.length); // 2

// let colors = new Array();
// let count = colors.push("red", "greed");
// console.log(count); // 2
// count = colors.push("black");
// console.log(count); // 3

// let item = colors.shift(); // 取得第一项
// console.log(item); // red
// console.log(colors.length); // 2

// let colors = new Array(); // 创建一个数组
// let count = colors.unshift("red", "green");
// console.log(count); // 2

// count = colors.unshift("black");
// console.log(count); // 3

// let item = colors.pop();
// console.log(item); // green
// console.log(colors.length); // 2

// let numbers = [1, 5, 10, 2, 8];
// // 默认排序(按字符串)
// console.log(numbers.sort()); // [ 1, 10, 2, 5, 8 ]
// //数值排序
// console.log(numbers.sort((a, b) => a - b)); // [ 1, 2, 5, 8, 10 ]
// console.log(numbers.sort((a, b) => b - a)); //[ 10, 8, 5, 2, 1 ]

// // 对象数组排序
// let users = [
//   { name: "John", age: 30 },
//   { name: "Jane", age: 25 },
//   { name: "Bob", age: 35 },
// ];
// console.log(users.sort((a, b) => a.age - b.age));

//操作方法
//concat - 合并数组
// let colors = ["red", "green", "blue"];
// let newColors = ["black", "brown"];
// let moreNewColors = ["pink", "cyan"];
// moreNewColors[Symbol.isConcatSpreadable] = false;

// let colors2 = colors.concat(newColors);
// let colors3 = colors.concat(moreNewColors);
// console.log(colors2); // [ 'red', 'green', 'blue', 'black', 'brown' ]
// console.log(colors3); // [ 'red', 'green', 'blue',  ["pink", "cyan"]]

// slice - 截取数组
// let colors = ["red", "green", "blue", "pink", "brown"];
// let colors2 = colors.slice(1);
// let colors3 = colors.slice(1, 3);
// let colors4 = colors.slice(-3);
// console.log(colors2); // [ 'green', 'blue', 'pink', 'brown' ]
// console.log(colors3); // [ 'green', 'blue' ]
// console.log(colors4); // [ 'blue', 'pink', 'brown' ]

// splice - 数组操作
// let arr = [1, 2, 3, 4, 5];

//删除
// let removed = arr.splice(0, 2); // 从索引0开始删除2个元素
// console.log(arr); // [3,4,5]
// console.log(removed); // [1,2]
// //插入
// arr.splice(1, 0, "a", "b"); // 从索引1开始插入，不删除
// console.log(arr); // [ 3, 'a', 'b', 4, 5 ]
// //替换
// arr.splice(2, 1, "c"); // 索引2开始删除1个元素，插入'c'
// console.log(arr); //[ 3, 'a', 'c', 4, 5 ]

// let numbers = [1, 2, 3, 4, 5];
// // reduce - 累加器
// let sum = numbers.reduce((acc, curr) => acc + curr, 0);
// console.log(sum); // 15

// // reduceRight - 从右向左
// let reversed = numbers.reduceRight((acc, curr) => [...acc, curr], []);
// console.log(reversed); // [5, 4, 3, 2, 1]

// // reduce 的复杂应用
// let stats = numbers.reduce(
//   (acc, curr) => {
//     acc.sum += curr;
//     acc.product *= curr;
//     return acc;
//   },
//   { sum: 0, product: 1 }
// );

// console.log(stats); // {sum: 15, product: 120}

// let set = new Set();
// // 添加值
// set.add(1);
// set.add(2);
// set.add(2); // 重复值会被忽略
// set.add("hello");
// set.add({}); // 对象引用不同，可以添加
// console.log(set.size); // 4
// // 检查存在
// console.log(set.has(1)); // true
// // 删除
// set.delete(1);
// // 清空
// set.clear();

// // 1. 数组去重
// let numbers = [1, 2, 2, 3, 4, 4, 5];
// let unique = [...new Set(numbers)];
// console.log(unique); // [ 1, 2, 3, 4, 5 ]

// // 2. 集合运算
// let setA = new Set([1, 2, 3]);
// let setB = new Set([2, 3, 4]);

// // 并集
// let union = new Set([...setA, ...setB]);
// console.log([...union]); // [ 1, 2, 3, 4 ]

// //交集
// let intersection = new Set([...setA].filter((x) => setB.has(x)));
// console.log([...intersection]); // [ 2, 3 ]

// //差集
// let difference = new Set([...setA].filter((x) => !setB.has(x)));
// console.log([...difference]); // [ 1 ]

// let arr1 = [1, 2, 3];
// let arr2 = [...arr1];
// console.log(arr1);
// console.log(arr2);
// console.log(arr1 === arr2); // false

// let arr1 = [{}];
// let arr2 = [...arr1];
// arr1[0].foo = "bar";

// console.log(arr2[0]); // { foo: 'bar' }

// 自定义可迭代对象
// const myIterable = {
//   data: [1, 2, 3, 4, 5],
//   [Symbol.iterator]() {
//     let index = 0;
//     const data = this.data;
//     return {
//       next() {
//         if (index < data.length) {
//           return { value: data[index++], done: false };
//         } else {
//           return { value: undefined, done: true };
//         }
//       },
//     };
//   },
// };

// for (const item of myIterable) {
//   console.log(item); // 1, 2, 3, 4, 5
// }

// let arr = ["foo"];
// let iter = arr[Symbol.iterator]();
// console.log(iter.next()); // { value: 'foo', done: false }
// console.log(iter.next()); // { value: undefined, done: true }

// let arr = [1, 2, 3, 4, 5];
// let iter = arr[Symbol.iterator]();

// for (let i of iter) {
//   console.log(i); // 1 2 3
//   if (i > 2) {
//     break;
//   }
// }

// for (let i of iter) {
//   console.log(i); // 4 5
// }

// const myIterable = {
//   data: 1,
//   [Symbol.iterator]() {
//     let count = this.data;
//     return {
//       next() {
//         if (count >= 5) {
//           return { value: undefined, done: true };
//         }
//         return { value: count++, done: false };
//       },

//       // 可选的 return 方法，用于提前终止
//       return(value) {
//         console.log("迭代器被提前终止");
//         return { value, done: true };
//       },

//       // 可选的 throw 方法，用于处理错误
//       throw(error) {
//         console.log("迭代器抛出错误:", error);
//         return { value: undefined, done: true };
//       },
//     };
//   },
// };

// // 情况1：使用for...of循环，提前break
// for (const value of myIterable) {
//   console.log(value);
//   if (value === 3) {
//     break; // 提前终止，会触发return方法
//   }
// }

// //情况2：使用for...of循环，continue
// for (const value of myIterable) {
//   console.log(value);
//   if (value === 3) {
//     continue; // 跳过一次迭代， 不会触发return 方法
//   }
// }

// //情况3：使用解构赋值，只取前两个值
// const [a, b] = myIterable;
// console.log(a, b); // 取前两个值，然后会提前终止

// //情况4：手动调用return方法
// console.log("\n手动调用return：");
// const iter = myIterable[Symbol.iterator]();
// console.log(iter.next()); // { value: 1, done: false }
// iter.return(); // 迭代器被提前终止
// console.log(iter.next()); // { value: 2, done: false }

// //清空5：使用 throw() 方法处理错误
// try {
//   for (const value of myIterable) {
//     console.log(value);
//     if (value === 3) {
//       throw new Error("模拟错误"); // 迭代器被提前终止
//     }
//   }
// } catch (error) {
//   console.log("捕获到错误：", error.message); // 捕获到错误： 模拟错误
// }

// function* timingDemo() {
//   //   console.log("1. 第一个yield之前");
//   const input1 = yield "输出A"; // 第一次next()输出'A'，等待输入

//   //   console.log("2. 收到输入1:", input1);
//   const input2 = yield "输出B"; // 第二次next()输出'B'，等待输入

//   //   console.log("3. 收到输入2:", input2);
//   return "最终结果";
// }

// const gen = timingDemo();

// // 第一次调用：输出'A'，暂停在第一个yield
// console.log("调用1:", gen.next());
// // 输出: 1. 第一个yield之前
// // 返回: { value: '输出A', done: false }

// // 第二次调用：传入'数据1'，输出'B'，暂停在第二个yield
// console.log("调用2:", gen.next("数据1"));
// // 输出: 2. 收到输入1: 数据1
// // 返回: { value: '输出B', done: false }

// // 第三次调用：传入'数据2'，函数结束
// console.log("调用3:", gen.next("数据2"));
// // 输出: 3. 收到输入2: 数据2
// // 返回: { value: '最终结果', done: true }

// function* nTimes(n) {
//   if (n > 0) {
//     yield* nTimes(n - 1);
//     yield n - 1;
//   }
// }
// for (const x of nTimes(3)) {
//   console.log(x);
// }

// Object.assign( ) 复制一个或多个源对象的所有可枚举属性到目标对象
// let target = { a: 1, b: 2 };
// let source1 = { b: 3, c: 4 };
// let source2 = { c: 5, d: 6 };
// Object.assign(target, source1, source2);
// console.log(target); // { a: 1, b: 3, c: 5, d: 6 }

// Object.keys() - 返回一个包含所有自身可枚举属性名称的数组
// let person = { name: "张三", age: 30 };
// console.log(Object.keys(person));
// // Object.values() - 返回一个包含所有可枚举属性值的数组
// console.log(Object.values(person));
// // Object.entries() - 返回一个包含所有可枚举属性键值对的数组
// console.log(Object.entries(person));
// Object.fromEntries() - 将键值对列表转换为对象
// let entries = [
//   ["name", "李四"],
//   ["age", 25],
// ];
// let obj = Object.fromEntries(entries);
// console.log(obj); // { name: '李四', age: 25 }
// Object.create() - 使用指定的原型对象和属性创建一个新对象
// let parent = {
//   name: "",
//   sayHello: function () {
//     console.log(`Hello,My name is ${this.name}`);
//   },
// };
// let child = Object.create(parent, {
//   name: { value: "小明", writable: true, enumerable: true },
//   age: { value: 10 },
// });
// child.sayHello(); // Hello,My name is 小明
// Object.defineProperty() - 定义或修改对象的属性
// let obj = {};
// Object.defineProperty(obj, "name", {
//   value: "张三",
//   writable: false, // 不可写
//   enumerable: true, //可枚举
//   configurable: false, //不可配置
// });
// obj.name = "李四"; // 严格模式下会报错，非严格模式下静默失败
// console.log(obj.name); // 张三

// Object.defineProperties() - 一次定义多个属性
// let obj = {};
// Object.defineProperties(obj, {
//   name: {
//     value: "张三",
//     writable: true,
//     // enumerable: true,
//   },
//   age: {
//     value: 30,
//     writable: false,
//   },
// });
// Object.getOwnPropertyDescriptor() - 获取属性的描述符
// let descriptor = Object.getOwnPropertyDescriptor(obj, "name");
// console.log(descriptor);
// let descriptors = Object.getOwnPropertyDescriptors(obj);
// console.log(descriptors);

//Object.getOwnPropertyNames() - 返回所有自身属性的名称（包括不可枚举属性）（包括不可枚举属性）
// console.log(Object.getOwnPropertyNames(obj));
// console.log(Object.entries(obj));

//Object.getPrototypeOf() - 返回指定对象的原型
// let parent = {};
// let child = Object.create(parent);
// console.log(Object.getPrototypeOf(child) === parent); // true

// Object.setPrototypeOf() - 设置对象的原型
// let parent = {
//   greet: function () {
//     console.log("Hello");
//   },
// };
// let child = {};
// Object.setPrototypeOf(child, parent);
// child.greet(); // "Hello"

//hasOwnProperty() - 检查属性是否是自身属性（非继承）
// let obj = { a: 1 };
// console.log(obj.hasOwnProperty("a")); // true
// console.log(obj.hasOwnProperty("toString")); // false

// isPrototypeOf() - 检查一个对象是否在另一个对象的原型链上
// let parent = {};
// let child = Object.create(parent);
// console.log(parent.isPrototypeOf(child)); //true

// propertyIsEnumerable() - 检查属性是否可枚举
// let obj = { a: 1 };
// Object.defineProperty(obj, "b", { value: 2, enumerable: false });
// console.log(obj.propertyIsEnumerable("a")); // true
// console.log(obj.propertyIsEnumerable("b")); // false

// let target = { a: 1, b: 2 };
// let source1 = { b: 3, c: 4, d: { name: "zzz" } };
// Object.assign(target, source1);
// source1.d.name = "aaa";
// console.log(target); // { a: 1, b: 3, c: 5, d: 6 }

// let obj = { a: 1 };
// Object.preventExtensions(obj);
// obj.b = 2; // 非严格模式下静默失败，严格模式下报错
// console.log(obj); // { a: 1 }

// let obj = { a: 1 };
// Object.seal(obj);
// delete obj.a; // 非严格模式下静默失败，严格模式下报错
// console.log(obj.a); // 1

// let obj = { a: 1, b: { c: 2 } };
// Object.freeze(obj);
// obj.a = 2; // 非严格模式下静默失败，严格模式下报错
// console.log(obj.a); // 1

// //注意：冻结是浅冻结，深层对象不受影响
// obj.b.c = 3; //修改成功
// console.log(obj.b.c); // 3

// // 深冻结函数
// function deepFreeze(obj) {
//   Object.freeze(obj);
//   for (let key in obj) {
//     if (
//       obj.hasOwnProperty(key) &&
//       typeof obj[key] === "object" &&
//       obj[key] !== null
//     ) {
//       deepFreeze(obj[key]);
//     }
//   }
// }
// deepFreeze(obj);
// obj.b.c = 5; //修改失败
// console.log(obj.b.c); // 3

// function Person(name, age) {
//   this.name = name;
//   this.age = age;
// }
// const person = new Person("Mark", 13);
// console.log(person.__proto__ === Person.prototype); // true
// console.log(Person.prototype.__proto__ === Object.prototype); // true
// console.log(Person.prototype.constructor === Person); // true

// let obj = {};
// let arr = [];
// // 不推荐的方式（已弃用，但很多环境扔支持)
// console.log(obj.__proto__); // Object.prototype
// console.log(arr.__proto__); // Array.prototype

// //推荐的方式
// console.log(Object.getPrototypeOf(obj)); // Object.prototype
// console.log(Object.getPrototypeOf(arr)); // Array.prototype

// // 设置原型
// let animal = { eats: true };
// let rabbit = { jumps: true };
// // rabbit.__proto__ = animal
// Object.setPrototypeOf(rabbit, animal);
// console.log(rabbit.eats); // true

// // 创建时指定原型
// let dog = Object.create(animal, {
//   barks: { value: true },
// });
// console.log(dog.eats); // true
// console.log(dog.barks); // true

// let animal = { eats: true };
// let rabbit = Object.create(animal);
// let longEar = Object.create(rabbit);

// // 检查原型关系
// console.log(animal.isPrototypeOf(rabbit)); // true
// console.log(animal.isPrototypeOf(longEar)); // true
// console.log(rabbit.isPrototypeOf(longEar)); // true

// // instanceof 操作符
// function Animal() {}
// let cat = new Animal();
// console.log(cat instanceof Animal); // true
// console.log(cat instanceof Object); // true

// let animal = {
//   eats: true,
//   walk() {
//     console.log("动物走路");
//   },
// };
// let rabbit = Object.create(animal);
// rabbit.eats = false; // 创建自身属性，遮蔽原型属性

// console.log(rabbit.eats); // false
// console.log(Object.getPrototypeOf(rabbit).eats); // true（原型属性）

// //删除自身属性后，可以重新访问原型属性
// delete rabbit.eats;
// console.log(rabbit.eats); // true(原型属性)

// function Animal(name) {
//   this.name = name;
// }
// Animal.prototype.speak = function () {
//   return "动物声音";
// };
// function Dog(name) {
//   Animal.call(this, name); // 调用父类构造函数
// }
// //设置原型链
// Dog.prototype = Object.create(Animal.prototype);
// Dog.prototype.constructor = Dog;

// function Cat(name) {
//   Animal.call(this, name); // 调用父类构造函数
// }

// Cat.prototype = Object.create(Animal.prototype);
// Cat.prototype.constructor = Cat;

// //重写方法
// Dog.prototype.speak = function () {
//   return "汪汪！";
// };
// let dog = new Dog("旺财");
// console.log(dog.speak()); // "汪汪！"

// Cat.prototype.speak = function () {
//   return "喵~";
// };
// let cat = new Cat("咪咪");
// console.log(cat.speak()); // "喵~"

// function Animal(name) {
//   this.name = name;
//   this.eats = true;
// }
// Animal.prototype.walk = function () {
//   return `${this.name} 在走路`;
// };
// function Dog(name, breed) {
//   Animal.call(this, name); // 继承实例属性
//   this.breed = breed;
// }
// // 继承原型方法
// Dog.prototype = Object.create(Animal.prototype);
// Dog.prototype.constructor = Dog;

// // 添加子类方法
// Dog.prototype.bark = function () {
//   return "汪汪！";
// };

// let myDog = new Dog("旺财", "金毛");
// console.log(myDog.walk()); // "旺财 在走路"
// console.log(myDog.bark()); // "汪汪！"

// console.log(FuctionExpression); //  FuctionExpression() {}
// function FuctionExpression() {}

// console.log(ClassExpression); // Cannot access 'ClassExpression' before initialization
// class ClassExpression {}

// function Person() {
//   this.sayHello = function () {
//     console.log("你好");
//   };
// }
// class Animal {}

// // 把window作为this来构建实例
// Person();
// sayHello(); // 你好

// //BUG
// // Animal(); // Class constructor Animal cannot be invoked without 'new'

class DatabaseConnection {
  static #config;
  static #connection;

  //静态初始化块
  static {
    try {
      this.#config = this.#loadConfigFromFile();
    } catch (error) {
      this.#config = { url: "default_url" };
      console.error("Failed to initialize database:", error);
    }
  }

  static #loadConfigFromFile() {
    console.log("加载设置...");
    return { url: "xxxx_url" };
  }
}
